﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>

//namespace fang
//{
//	int a = 10;
//	int b = 20;
//}

//int main()
//{
//	//// 编译报错：error C2065: “a”: 未声明的标识符
//	printf("%d \n", fang::a);
//	return 0;
//}

// using将命名空间中某个成员展开

//namespace fang
//{
//	int a = 10;
//	int b = 20;
//}
//
//using fang::a;//把a单独暴露到全局
//
//int b = 99;
//
//int main()
//{
//	printf("%d\n",a);
//	printf("%d\n",a);
//	printf("%d\n",a);
//	printf("%d\n",a);
//	printf("%d\n",a);
//	fang::b++;
//	printf("%d\n",fang::b);
//
//	printf("%d\n", b);//全局的b
//	return 0;
//}

//int main()
//{
//	// << 流插入
//	std::cout << "您好" << std::endl;
//	int a = 10;
//	std::cout << a << std::endl << std::endl;
//
//	double b = 5.99;
//	std::cout << b << std::endl;
//}

//using std::cout;
//using std::cin;
//
//int main()
//{
//	int a = 0;
//	double b = 10;
//	//输入流
//	cin >> a >> b;
//	//输出流
//	cout << a << " " << b << std::endl;
//
//}

//
//#include<iostream>
//using namespace std;
//int main()
//{
//	// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
//	// 可以提⾼C++IO效率
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr);
//	cout.tie(nullptr);
//	return 0;
//}

//#include <iostream>
//#include <assert.h>
//using namespace std;
//void Func(int a = 0)
//{
//	cout << a << endl;
//}
//int main()
//{
//	Func(); // 没有传参时，使⽤参数的默认值
//	Func(10); // 传参时，使⽤指定的实参
//	return 0;
//}
//
//#include <iostream>
//#include <assert.h>
//using namespace std;
//
//void fang(int a = 0)
//{
//	cout << a << endl;
//}
//int main()
//{
//	fang();// 没有传参时，使⽤参数的默认值
//	fang(10); // 传参时，使⽤指定的实参
//	return 0;
//}


//#include <iostream>
//using namespace std;
//// 全缺省
//void Func1(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//// 半缺省
//void Func2(int a, int b = 10, int c = 20)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//int main()
//{
//	Func1();
//	Func1(1);
//	Func1(1, 2);
//	Func1(1, 2, 3);
//	return 0;
//}


#include <iostream>
using namespace std;

// 半缺省
void Func2(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main1()
{
	Func2(100);
	Func2(100, 200);
	Func2(100, 200, 300);
	return 0;
}

//// Stack.h
//#include <iostream>
//#include <assert.h>
//using namespace std;
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST* ps, int n);
//
//// Stack.cpp
//
//// 缺省参数不能声明和定义同时给
//void STInit(ST* ps, int n = 4 )
//{
//	assert(ps && n > 0);
//	ps->a = (STDataType*)malloc(n * sizeof(STDataType));
//	ps->top = 0;
//	ps->capacity = n;
//}
//
//// test.cpp
//
//int main()
//{
//	ST s1;
//	STInit(&s1);
//	// 确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容
//	ST s2;
//	STInit(&s2, 1000);
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//// 1、参数类型不同
//int Add(int left, int right)
//{
//	cout << "int Add(int left, int right)" << endl;
//	return left + right;
//}
//double Add(double left, double right)
//{
//	cout << "double Add(double left, double right)" << endl;
//	return left + right;
//}
//
//int main()
//{
//	Add(10, 20);
//	Add(10.1, 20.2);
//	//f();
//	//f(10);
//	//f(10, 'a');
//	//f('a', 10);
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//// 2、参数个数不同
//void f()
//{
//	cout << "f()" << endl;
//}
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}
//
//int main()
//{
//
//	f();
//	f(10);
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//// 3、参数类型顺序不同
//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//}
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}
//
//int main()
//{
//	f(10, 'a');
//	f('a', 10);
//	return 0;
//}
//
//// 下⾯两个函数构成重载
//// f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
//void f1()
//{
//	cout << "f()" << endl;
//}
//void f1(int a = 10)
//{
//	cout << "f(int a)" << endl;
//}
//
//
//int main()
//{
//
//
//	return 0;
//}
#include <iostream>
using namespace std;

//int main()
//{
//	int a = 0;
//	// 引⽤：b和c是a的别名
//	int& b = a;
//	int& c = a;
//	// 也可以给别名b取别名，g相当于还是a的别名
//	int& g = b;
//	g++;
//
//	// 这⾥取地址我们看到是⼀样的
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//	cout << g << endl;
//
//	return 0;
//}

//int main()
//{
//	int a = 1;
//	int* p1 = &a;
//	int*& p2 = p1;
//
//	int e = 99;
//	p2 = &e;
//
//	cout << *p2 << endl;
//	return 0;
//}
//
//#include <iostream>
//using namespace std;
//
////交换
//void jh(int& x, int& y)
//{
//	int tab = x;
//	x = y;
//	y = tab;
//}
//
//int main()
//{
//	int a = 10;
//	int b = 99;
//	cout << "没交换前：" << a << " " << b << endl;
//	//交换函数
//	jh(a, b);
//	cout << "交换后:" << a << " " << b << endl;
//	
//}
//

//#include<iostream>
//using namespace std;
//int main()
//{
//	int a = 10;
//	// 编译报错：“ra”: 必须初始化引⽤
//	//int& ra;
//	int& b = a;
//	int c = 20;
//	// 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向，
//	// 这⾥是⼀个赋值
//	b = c;
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	return 0;
//}


//#include<iostream>
//#include<assert.h>
//using namespace std;
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST& rs, int n = 4)
//{
//	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
//	rs.top = 0;
//	rs.capacity = n;
//}
//// 栈顶，入数据
//void STPush(ST& rs, STDataType x)
//{
//	// 满了， 扩容
//	if (rs.top == rs.capacity)
//	{
//		printf("扩容\n");
//		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
//			sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//		rs.a = tmp;
//		rs.capacity = newcapacity;
//	}
//	rs.a[rs.top] = x;
//	rs.top++;
//}
//
//
//
//// 栈顶
//int& STTop(ST& rs)
//{
//	assert(rs.top > 0);
//	return rs.a[rs.top - 1];
//}
//
//int& fun()
//{
//	int a = 10;
//	a++;
//
//	return a;
//}
//
//int main()
//{
//	// 调⽤全局的
//	ST st1;
//	STInit(st1);
//	STPush(st1, 1);
//	STPush(st1, 2);
//	cout << STTop(st1) << endl;
//
//	//修改栈顶数据
//	STTop(st1) += 10;
//	cout << STTop(st1) << endl;
//
//	fun() += 10;
//
//	return 0;
//}


//#include<iostream>
//using namespace std;
//typedef struct SeqList
//{
//	int a[10];
//	int size;
//}SLT;
//// ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复
////杂的指针，但是很多同学没学过引⽤，导致⼀头雾⽔。
//void SeqPushBack(SLT& sl, int x)
//{}
//typedef struct ListNode
//{
//	int val;
//	struct ListNode* next;
//}LTNode, * PNode;
//
//// 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量取别名
//// 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
////void ListPushBack(LTNode** phead, int x)
////void ListPushBack(LTNode*& phead, int x)
//void ListPushBack(PNode& phead, int x)
//{
//	PNode newnode = (PNode)malloc(sizeof(LTNode));
//	newnode->val = x;
//	newnode->next = NULL;
//	if (phead == NULL)
//	{
//		phead = newnode;
//	}
//	else
//	{
//		//...
//	}
//}
//
//int main()
//{
//	PNode plist = NULL;
//	ListPushBack(plist, 1);
//	return 0;
//}

//int main()
//{
//	//const int a = 10;
//	//////权限不能放大
//	////int& ps = a;
//	//const int& ps = a;
//
//	int b = 10;
//	const int& ps = b;
//	ps++;
//	b++;
//	return 0;
//}
//
//int main()
//{
//	// 权限不能放大
//	const int a = 10;
//	const int* p1 = &a;
//	//int* p2 = p1;
//
//	// 权限可以缩小
//	int b = 20;
//	int* p3 = &b;
//	const int* p4 = p3;
//
//	// 不存在权限放大，因为const修饰的是p5本身不是指向的内容
//	int* const p5 = &b;
//	int* p6 = p5;
//
//	return 0;
//}
//
//#include<iostream>
//using namespace std;
//int main()
//{
//	int a = 10;
//	const int& ra = 30;
//	// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
//	// int& rb = a * 3;
//	const int& rb = a * 3;
//
//
//	double d = 12.34;
//
//	const int& rd = d;
//
//
//	return 0;
//}
//
//
//
//
//void f1(const int& rx)
//{
//
//}
//
//int main()
//{
//	const int xx = 20;
//	int a = 10;
//	const int& rb = a * 3;
//
//	double d = 12.34;
//	const int& rd = d;
//
//	f1(xx);
//	f1(a);
//	f1(a*3);
//	f1(d);
//
//	return 0;
//}

//#define add(a,b) ((a)+(b))
//
//int main()
//{
//	int ret = add(1, 2);
//	printf("%d ", ret);
//
//	std::cout << add(1, 2) << std::endl;
//}

#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
	int ret = x + y;
	ret += 1;
	ret += 1;
	ret += 1;
	return ret;
}
int main()
{
	// 可以通过汇编观察程序是否展开
	// 有call Add语句就是没有展开，没有就是展开了
	int ret = Add(1, 2);
	cout << Add(1, 2) * 5 << endl;
	return 0;
}

#include<iostream>
using namespace std;
// 实现⼀个ADD宏函数的常⻅问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)
// 正确的宏实现
#define ADD(a, b) ((a) + (b))
// 为什么不能加分号?
// 为什么要加外⾯的括号?
// 为什么要加⾥⾯的括号?
int main()
{
	int ret = ADD(1, 2);
	cout << ADD(1, 2) << endl;
	cout << ADD(1, 2) * 5 << endl;
	int x = 1, y = 2;
	ADD(x & y, x | y); // -> (x&y+x|y)
	return 0;
}